<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script src="lodash.min.js"></script>
		<script>
			// 创建一个组成对象，key（键）是经过 iteratee（迭代函数） 执行处理collection中每个元素后返回的结果，每个key（键）对应的值是 iteratee（迭代函数）返回该key（键）的次数（注：迭代次数）。
			_.countBy([6.1, 4.2, 6.3], Math.floor);
			// => { '4': 1, '6': 2 }	4出现1次，6出现2次
			// The `_.property` iteratee shorthand.
			_.countBy(['one', 'two', 'three'], 'length');
			// => { '3': 2, '5': 1 }	'one''two'的'length'长度为3，故3出现2次，'three'的'length'长度为5，故3出现1次
			
			
			// 遍历值和键，与_.each等效；_.forEachRight反向遍历
			_.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
			  console.log(key);
			});
			// => Logs 'a' then 'b'
			
			
			// 遍历数组每个值，如果每个值都满足参数二（可以是函数）的要求，则返回true；不同的是_.some，如果存在值满足条件，则返回true
			_.every([true, 1, null, 'yes'], Boolean);
			// => false
			var users = [
			  { 'user': 'barney', 'age': 36, 'active': false },
			  { 'user': 'fred',   'age': 40, 'active': false }
			];
			_.every(users, { 'user': 'barney', 'active': false });
			// => false
			_.every(users, ['active', false]);
			// => true
			_.every(users, 'active');
			// => false
			
			
			
			
			// 返回满足条件的部分,find、findLast类似，会返回第一个满足条件的对象
			var users = [
			  { 'user': 'barney', 'age': 36, 'active': true },
				{ 'user': 'barney', 'age': 236, 'active': true },
			  { 'user': 'fred',   'age': 40, 'active': false }
			];
			_.filter(users, function(o) { return !o.active; });
			// => objects for ['fred']
			// The `_.matches` iteratee shorthand.
			_.filter(users, { 'age': 36, 'active': true });
			// => objects for ['barney']
			
			
			var users = [
			  { 'user': 'fred',   'age': 48 },
			  { 'user': 'barney', 'age': 34 },
			  { 'user': 'fred',   'age': 40 },
			  { 'user': 'barney', 'age': 36 }
			];
			// 以 `user` 升序排序 再  `age` 以降序排序。
			console.log(_.orderBy(users, ['user', 'age'], ['asc', 'desc']));
			// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
			
			
			// 创建一个分成两组的元素数组，第一组包含predicate（断言函数）返回为 truthy（真值）的元素，第二组包含predicate（断言函数）返回为 falsey（假值）的元素。
			users = [
			  { 'user': 'barney',  'age': 36, 'active': false },
			  { 'user': 'fred',    'age': 40, 'active': true },
			  { 'user': 'pebbles', 'age': 1,  'active': false }
			];
			_.partition(users, function(o) { return o.active; });
			// => objects for [['fred'], ['barney', 'pebbles']]
			_.partition(users, { 'age': 1, 'active': false });
			// => objects for [['pebbles'], ['barney', 'fred']]
			
			
			// invokeMap参数二函数处理参数一的一维或二维数组，参数三作为参数二的参数
			_.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
			// => [[1, 5, 7], [1, 2, 3]]
			_.invokeMap([123, 456], String.prototype.split, '');
			// => [['1', '2', '3'], ['4', '5', '6']]
			
			
			// 参数二函数的参数为参数一的各个对象；生成的对象中，键为参数二返回值，值为参数一的对象
			var array = [
			  { 'dir': 'left', 'code': 97 },
			  { 'dir': 'right', 'code': 100 }
			];
			_.keyBy(array, function(o) {
			  return String.fromCharCode(o.code);
			});
			// => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
			
			
			
			
			// 从collection（集合）中获得 n 个随机元素。
			_.sampleSize([1, 2, 3], 2);
			// => [3, 1]
			_.sampleSize([1, 2, 3], 4);
			// => [2, 3, 1]
			
			
			// 创建一个被打乱值的集合，英译为洗牌
			_.shuffle([1, 2, 3, 4]);
			// => [4, 1, 3, 2]
			
			// 使用duplicate返回值替换数组的各个元素；其中duplicate参数分别为数组的值、顺序、数组本身
			function duplicate(n,m,arr) {
				console.log(arguments);
			  return ['value',n,'key', m,'arr',arr];
			}
			console.log(_.flatMap([3, 4,6], duplicate));
			
			// 不同于duplicate，他会把返回值数组完全展开，类似的flatMapDepth可以再加一个参数控制展开层数
			function duplicateDeep(n,m,arr) {
			  return [['value',n,'key', m,'arr',arr]];
			}
			console.log(_.flatMapDeep([3, 5], duplicateDeep));
			
			// 类似length
			_.size([1, 2, 3]);
			// => 3
			_.size({ 'a': 1, 'b': 2 });
			// => 2
			_.size('pebbles');
			// => 7
		</script>
	</body>
</html>